#ifndef __ZHONG_RELATION__
#define __ZHONG_RELATION__
#include "Factory.hpp"
#include "relation.hxx"
#include "relation-odb.hxx"

namespace bite_im
{
    class RelationTable
    {
    public:
        using ptr = std::shared_ptr<RelationTable>;
        RelationTable() {}
        RelationTable(const DBPtr &db) : _db(db) {}

        // 新增关系信息
        bool insert(const std::string &user_id, const std::string &peer_id)
        {
            // 关系信息 {user, peer} 和 {peer, user} 双向关系
            try
            {
                // 获取事务对象，开启事务
                odb::transaction transaction(_db->begin());

                Relation r1(user_id, peer_id);
                Relation r2(peer_id, user_id);
                _db->persist(r1);
                _db->persist(r2);
                // 提交事务
                transaction.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("新增好友关系[{}-{}]出现异常，原因[{}]", user_id, peer_id, e.what());
                return false;
            }
            return true;
        }
        // 删除好友关系
        bool remove(const std::string &user_id, const std::string &peer_id)
        {
            try
            {
                // 获取事务对象，开启事务
                odb::transaction transaction(_db->begin());
                using query = odb::query<Relation>;
                // 双向删除
                _db->erase_query<Relation>(query::user_id == user_id && query::peer_id == peer_id);
                _db->erase_query<Relation>(query::user_id == peer_id && query::peer_id == user_id);
                // 提交事务
                transaction.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("好友关系[{}-{}]删除失败，原因[{}]", user_id, peer_id, e.what());
                return false;
            }
            return true;
        }
        // 查询是否为好友关系--防止重复insert
        bool exist(const std::string &user_id, const std::string &peer_id)
        {
            using query = odb::query<Relation>;
            using result = odb::result<Relation>;
            result ret;
            bool flag = false;
            try
            {
                // 3.获取事务对象，开启事务
                odb::transaction transaction(_db->begin());

                ret = _db->query<Relation>(query::user_id == user_id && query::peer_id == peer_id);
                
                flag = (ret.empty() == false) ? true : false;   // 需要用临时变量维护，ret对象提交事务后会失效
                // 4.提交事务
                transaction.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("好友关系[{}-{}]查询失败，原因[{}]", user_id, peer_id, e.what());
            }

            return flag;
        }
        // 获取某个用户的所有好友id---后续将好友id进行用户子服务获取用户信息
        std::vector<std::string> friends(const std::string &user_id)
        {
            std::vector<std::string> friend_list;
            try
            {
                // 3.获取事务对象，开启事务
                odb::transaction transaction(_db->begin());
                using query = odb::query<Relation>;
                using result = odb::result<Relation>;

                result ret(_db->query<Relation>(query::user_id == user_id));
                for (auto it = ret.begin(); it != ret.end(); ++it)
                {
                    friend_list.push_back(it->peer_id());
                }
                // 4.提交事务
                transaction.commit();
            }
            catch (std::exception &e)
            {
                LOG_ERROR("获取[{}]所有好友关系失败，原因[{}]", user_id, e.what());
            }
            // 这个接口的message_list是先将离start最近的数据先插入进message_list中
            // 也就是最久的数据放在数组前，这个时候就不用逆序
            return friend_list;
        }

    private:
        DBPtr _db;
    };

}
#endif